diff --git a/doc/driver-model/design.rst b/doc/driver-model/design.rst
index 96525b6..92d1304 100644
--- a/doc/driver-model/design.rst
+++ b/doc/driver-model/design.rst
@@ -448,10 +448,10 @@
 
 .. code-block:: c
 
-	.platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
+	.platdata_auto = sizeof(struct dm_test_pdata),
 	.ofdata_to_platdata = testfdt_ofdata_to_platdata,
 
-The 'auto_alloc' feature allowed space for the platdata to be allocated
+The 'auto' feature allowed space for the platdata to be allocated
 and zeroed before the driver's ofdata_to_platdata() method is called. The
 ofdata_to_platdata() method, which the driver write supplies, should parse
 the device tree node for this device and place it in dev->platdata. Thus
@@ -464,7 +464,7 @@
 details.
 
 If you don't want to have the platdata automatically allocated then you
-can leave out platdata_auto_alloc_size. In this case you can use malloc
+can leave out platdata_auto. In this case you can use malloc
 in your ofdata_to_platdata (or probe) method to allocate the required memory,
 and you should free it in the remove method.
 
@@ -589,7 +589,7 @@
 
 To achieve this, the bus device can use dev->parent_platdata in each of its
 three children. This can be auto-allocated if the bus driver (or bus uclass)
-has a non-zero value for per_child_platdata_auto_alloc_size. If not, then
+has a non-zero value for per_child_platdata_auto. If not, then
 the bus device or uclass can allocate the space itself before the child
 device is probed.
 
@@ -695,24 +695,24 @@
 
 The steps are:
 
-   1. If priv_auto_alloc_size is non-zero, then the device-private space
+   1. If priv_auto is non-zero, then the device-private space
    is allocated for the device and zeroed. It will be accessible as
    dev->priv. The driver can put anything it likes in there, but should use
    it for run-time information, not platform data (which should be static
    and known before the device is probed).
 
-   2. If platdata_auto_alloc_size is non-zero, then the platform data space
+   2. If platdata_auto is non-zero, then the platform data space
    is allocated. This is only useful for device tree operation, since
    otherwise you would have to specific the platform data in the
    U_BOOT_DEVICE() declaration. The space is allocated for the device and
    zeroed. It will be accessible as dev->platdata.
 
-   3. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
+   3. If the device's uclass specifies a non-zero per_device_auto,
    then this space is allocated and zeroed also. It is allocated for and
    stored in the device, but it is uclass data. owned by the uclass driver.
    It is possible for the device to access it.
 
-   4. If the device's immediate parent specifies a per_child_auto_alloc_size
+   4. If the device's immediate parent specifies a per_child_auto
    then this space is allocated. This is intended for use by the parent
    device to keep track of things related to the child. For example a USB
    flash stick attached to a USB host controller would likely use this
@@ -726,7 +726,7 @@
    works the same way whether it was bound using a device tree node or
    U_BOOT_DEVICE() structure. In either case, the platform data is now stored
    in the platdata structure. Typically you will use the
-   platdata_auto_alloc_size feature to specify the size of the platform data
+   platdata_auto feature to specify the size of the platform data
    structure, and U-Boot will automatically allocate and zero it for you before
    entry to ofdata_to_platdata(). But if not, you can allocate it yourself in
    ofdata_to_platdata(). Note that it is preferable to do all the device tree
@@ -795,9 +795,9 @@
       - uclass data in dev->uclass_priv (for things the uclass stores
         about this device)
 
-   Note: If you don't use priv_auto_alloc_size then you will need to
+   Note: If you don't use priv_auto then you will need to
    allocate the priv space here yourself. The same applies also to
-   platdata_auto_alloc_size. Remember to free them in the remove() method.
+   platdata_auto. Remember to free them in the remove() method.
 
    5. The device is marked 'activated'
 
@@ -843,10 +843,10 @@
    be dynamically allocated, and thus needs to be deallocated during the
    remove() method, either:
 
-      - if the platdata_auto_alloc_size is non-zero, the deallocation
+      - if the platdata_auto is non-zero, the deallocation
         happens automatically within the driver model core; or
 
-      - when platdata_auto_alloc_size is 0, both the allocation (in probe()
+      - when platdata_auto is 0, both the allocation (in probe()
         or preferably ofdata_to_platdata()) and the deallocation in remove()
         are the responsibility of the driver author.
 
diff --git a/doc/driver-model/ethernet.rst b/doc/driver-model/ethernet.rst
index 1f5310d..781644d 100644
--- a/doc/driver-model/ethernet.rst
+++ b/doc/driver-model/ethernet.rst
@@ -28,14 +28,14 @@
 		.ofdata_to_platdata	= eth_ape_ofdata_to_platdata,
 		.probe			= eth_ape_probe,
 		.ops			= &eth_ape_ops,
-		.priv_auto_alloc_size	= sizeof(struct eth_ape_priv),
-		.platdata_auto_alloc_size = sizeof(struct eth_ape_pdata),
+		.priv_auto	= sizeof(struct eth_ape_priv),
+		.platdata_auto = sizeof(struct eth_ape_pdata),
 		.flags			= DM_FLAG_ALLOC_PRIV_DMA,
 	};
 
 struct eth_ape_priv contains runtime per-instance data, like buffers, pointers
 to current descriptors, current speed settings, pointers to PHY related data
-(like struct mii_dev) and so on. Declaring its size in .priv_auto_alloc_size
+(like struct mii_dev) and so on. Declaring its size in .priv_auto
 will let the driver framework allocate it at the right time.
 It can be retrieved using a dev_get_priv(dev) call.
 
@@ -43,7 +43,7 @@
 a hardware variant, the MAC address. ``struct eth_pdata eth_pdata``
 as the first member of this struct helps to avoid duplicated code.
 If you don't need any more platform data beside the standard member,
-just use sizeof(struct eth_pdata) for the platdata_auto_alloc_size.
+just use sizeof(struct eth_pdata) for the platdata_auto.
 
 PCI devices add a line pointing to supported vendor/device ID pairs:
 
diff --git a/doc/driver-model/of-plat.rst b/doc/driver-model/of-plat.rst
index 5848166..2df59ed 100644
--- a/doc/driver-model/of-plat.rst
+++ b/doc/driver-model/of-plat.rst
@@ -293,8 +293,8 @@
             .of_match       = mmc_ids,
             .ofdata_to_platdata = mmc_ofdata_to_platdata,
             .probe          = mmc_probe,
-            .priv_auto_alloc_size = sizeof(struct mmc_priv),
-            .platdata_auto_alloc_size = sizeof(struct mmc_platdata),
+            .priv_auto = sizeof(struct mmc_priv),
+            .platdata_auto = sizeof(struct mmc_platdata),
     };
 
     U_BOOT_DRIVER_ALIAS(mmc_drv, vendor_mmc) /* matches compatible string */
@@ -305,7 +305,7 @@
 There is just one driver C file for each struct, that can convert from the
 of-platdata struct to the standard one used by the driver.
 
-In the case where SPL_OF_PLATDATA is enabled, platdata_auto_alloc_size is
+In the case where SPL_OF_PLATDATA is enabled, platdata_auto is
 still used to allocate space for the platform data. This is different from
 the normal behaviour and is triggered by the use of of-platdata (strictly
 speaking it is a non-zero platdata_size which triggers this).
diff --git a/doc/driver-model/spi-howto.rst b/doc/driver-model/spi-howto.rst
index 9631a50..a12d692 100644
--- a/doc/driver-model/spi-howto.rst
+++ b/doc/driver-model/spi-howto.rst
@@ -231,7 +231,7 @@
 
 	U_BOOT_DRIVER(spi_exynos) = {
 	...
-		.platdata_auto_alloc_size = sizeof(struct exynos_spi_platdata),
+		.platdata_auto = sizeof(struct exynos_spi_platdata),
 
 
 Here is a sample function. It gets a pointer to the platform data and
@@ -335,7 +335,7 @@
 
 	U_BOOT_DRIVER(spi_exynos) = {
 	...
-		.priv_auto_alloc_size = sizeof(struct exynos_spi_priv),
+		.priv_auto = sizeof(struct exynos_spi_priv),
 
 
 Note that this is created before the probe method is called, and destroyed
@@ -621,7 +621,7 @@
 
 	U_BOOT_DRIVER(exynos_spi) = {
 	...
-		.per_child_auto_alloc_size	= sizeof(struct spi_slave),
+		.per_child_auto	= sizeof(struct spi_slave),
 	}
 
 
diff --git a/doc/driver-model/usb-info.rst b/doc/driver-model/usb-info.rst
index 1817df4..5f7cbfc 100644
--- a/doc/driver-model/usb-info.rst
+++ b/doc/driver-model/usb-info.rst
@@ -43,8 +43,8 @@
 		.probe = tegra_ehci_usb_probe,
 		.remove = tegra_ehci_usb_remove,
 		.ops	= &ehci_usb_ops,
-		.platdata_auto_alloc_size = sizeof(struct usb_platdata),
-		.priv_auto_alloc_size = sizeof(struct fdt_usb),
+		.platdata_auto = sizeof(struct usb_platdata),
+		.priv_auto = sizeof(struct fdt_usb),
 		.flags	= DM_FLAG_ALLOC_PRIV_DMA,
 	};
 
@@ -58,7 +58,7 @@
 most cases, since they are all EHCI-compatible. For EHCI there are also some
 special operations that can be overridden when calling ehci_register().
 
-The driver can use priv_auto_alloc_size to set the size of its private data.
+The driver can use priv_auto to set the size of its private data.
 This can hold run-time information needed by the driver for operation. It
 exists when the device is probed (not when it is bound) and is removed when
 the driver is removed.
diff --git a/doc/imx/clk/ccf.txt b/doc/imx/clk/ccf.txt
index e40ac36..f47ca88 100644
--- a/doc/imx/clk/ccf.txt
+++ b/doc/imx/clk/ccf.txt
@@ -37,7 +37,7 @@
   modify clk-uclass.c file and add there struct uc_clk_priv, which would have
   clock related members (like pointer to clk). As of this writing there is no
   such need, so to avoid extra allocations (as it can be auto allocated by
-  setting .per_device_auto_alloc_size = sizeof(struct uc_clk_priv)) the
+  setting .per_device_auto = sizeof(struct uc_clk_priv)) the
   uclass_priv stores the pointer to struct clk.
 
 * Non-CCF clocks do not have a pointer to a clock in clk->dev->priv. In the case